<?php
/* -------------------------------------------------------------------------------------
* 	ID:						$Id: class.page_break.php 135 2013-09-22 07:30:55Z phone.mueller@googlemail.com $
* 	Letzter Stand:			$Revision: 135 $
* 	zuletzt geaendert von:	$Author: siekiera $
* 	Datum:					$Date: 2013-09-22 07:30:55 +0000 (Sun, 22 Sep 2013) $
*
* 	SEO:mercari by Siekiera Media
* 	http://www.seo-mercari.de
*
* 	Copyright (c) since 2011 SEO:mercari
* --------------------------------------------------------------------------------------
* 	based on:
* 	(c) 2000-2001 The Exchange Project  (earlier name of osCommerce)
* 	(c) 2002-2003 osCommerce - www.oscommerce.com
* 	(c) 2003     nextcommerce - www.nextcommerce.org
* 	(c) 2005     xt:Commerce - www.xt-commerce.com
*
* 	Released under the GNU General Public License
* --------------------------------------------------------------------------------------
*
*	Funktion zum Blaettern
*   Funktion zum erstellen einer Linkliste, die das Blättern durch eine bestimmte Zahl von Ergebnissen erlaubt
*   @author Carsten Franke
*   @version 1.2
*   @copyright GPL
*/
 
require(DIR_WS_CLASSES.'class.collect_params.php');

class page_break extends collect_params {
	var $db;
	public $sql_string;
	public $result = false;
	public $set_entries;
	public $sLinks = false;
	public $smarty = false;
	public $setExternalLink;
	public $sep;
	public $raw_sql;
	public $perPage;
	public $page_name;
    public $page_style = false;
    
    function __construct($sql, $activePage = 1, $nav_links = true, $site, $page_style = '', $count_total_products = '') {
    	global $db;
		
		$this->site = $site;
		
    	$this->db = $db;
    	if(!empty($page_style))
			$this->page_style = $page_style;
		
		if(is_numeric($nav_links))
			$this->perPage = $nav_links;
		else
			$this->navLinks($nav_links);

		if(!empty($count_total_products) && $count_total_products > 0) {
			$this->setEntries($count_total_products);
			$this->result = true;

		} else {
			$this->raw_sql = $this->db->db_query($sql, true);
	    	$this->setEntries($this->raw_sql->_numOfRows);
	    	if($this->raw_sql->_numOfRows)
	    		$this->result = true;
    	}
    		
		$parameter = $this->setParam($site);
		
		if(substr($parameter, -1) == '&')
			$parameter = substr($parameter, 0, -1);

    	$this->parameters = $parameter;

        $this->setActivePage($activePage);
				
        $this->setExternalLink = href_link($this->parameters);

        if(strpos($this->parameters, '?'))
        	$this->parameters = href_link($this->parameters.'&page=');
        else
        	$this->parameters = href_link($this->parameters, 'page=');
		
        $this->setLinkHref($this->parameters);
        $this->setNumberFirstPage(1);
        $this->setEntriesPerPage($this->perPage);
        $this->setShowCount(4);
        $this->setShowSingleLink(false);
		$this->setShowContinuous(false);
		$this->setShowOuter(true);
		$this->setShowActiveLink(true);
		$this->setLinkFirstLastText(FIRST_PAGE, LAST_PAGE);
		$this->setLinkNextPrevText(NEXT_SITE, PREVIEW_SITE);
		$this->setDelimiter1(' ');
		$this->setDelimiter2(' ');
		$this->setDelimiter3(' ');
		$this->setDelimiter4(' ... ');

		if(strpos($this->setExternalLink, '?'))
			$this->sep = '&';
		else
			$this->sep = '?';
		
		$this->getSQL($sql, $activePage);
    }

    public function setParam($site) {
		global $current_category_id;
    	$uri = $site;

		if(MODULE_SEO_URL_INDEX_STATUS == 'True') {
			require_once(DIR_FS_INC.'inc.seo_url.php');
			!$seo_url ? $seo_url = new SeoUrl() : false;
			
			if(isset($_GET['products_id']))
				$uri = $seo_url->getSiteLink('products_id', $_GET['products_id'], $this->site);
			
			elseif(isset($_GET['cPath']))
				$uri = $seo_url->getSiteLink('cPath', $current_category_id, $this->site);

			elseif (isset($_GET['keywords']))
				$uri = $seo_url->getSiteLink('keywords', $_GET['keywords'], $this->site);

			elseif (isset($_GET['brand']))
				$uri = $seo_url->getSiteLink('brand', $_GET['brand'], $this->site);
			
			elseif (isset($_GET['tag']))
				$uri = $seo_url->getSiteLink('tag', $_GET['tag'], $this->site);
					
			elseif (isset($_GET['blog_item'])) {
				unset($_GET['blog_cat']);
				$uri = $seo_url->getSiteLink('blog_item', $_GET['blog_item'], $this->site);
				
			} elseif (isset($_GET['blog_cat']))
				$uri = $seo_url->getSiteLink('blog_cat', $_GET['blog_cat'], $this->site);

		} else {
			if (isset($_GET['products_id']))
				$uri = $site.'?products_id='.$_GET['products_id'];
				
			elseif(isset($_GET['cPath']))
				$uri = $site.'?cPath='.$_GET['cPath'];

			elseif (isset($_GET['keywords']))
				$uri = $site.'?keywords='.$_GET['keywords'];

			elseif (isset($_GET['brand']))
				$uri = $site.'?brand='.$_GET['brand'];
			
			elseif (isset($_GET['tag']))
				$uri = $site.'?tag='.$_GET['tag'];
				
			elseif (isset($_GET['blog_item']))
				$uri = $site.'?blog_cat='.$_GET['blog_cat'].'&blog_item='.$_GET['blog_item'];	
				
			elseif (isset($_GET['blog_cat']))
				$uri = $site.'?blog_cat='.$_GET['blog_cat'];
		}
    	return $uri;
    }

    public function getLinks() {
    	return ($this->entries > 0 ? $this->create() : '');
    }
	
	public function getSQL($sql, $page) {
		$check = $this->db->db_query($sql." LIMIT ".($this->getEntriesPerPage() * $this->getActivePage()).','. $this->perPage, true);
		if(!$check->_numOfRows && $page > 1) {
			$this->setActivePage($page-1);
			$this->getSQL($sql, ($page-1));
		} else
			$this->sql_string = $check;	
	}
	
    public function create($extra = '') {
        $activePage = &$this->activePage;
        $entries = &$this->entries;
        $entriesPerPage = &$this->entriesPerPage;
        $linkCount = &$this->linkCount;
        $linkCountSurround = &$this->linkCountSurround;
        $showCount = &$this->showCount;
        $showContinuous = &$this->showContinuous;
        $showOuter = &$this->showOuter;
        $showSingleLink = &$this->showSingleLink;
        $showActiveLink = &$this->showActiveLink;
        $pageNext = &$this->pageNext;
        $pagePrev = &$this->pagePrev;
        $pageFirst = &$this->pageFirst;
        $pageLast = &$this->pageLast;
        $links = &$this->links;
        if(!empty($extra))
			$this->extra = $extra;
        // Array neu initialisieren
        $links = array ();

        // Erst einmal testen, ob die Werte okay sind
        if ($entries == 0) {
            $links[0] = '';
            return $links;
        }

        // Anzahl aller moeglichen Links zu den Seiten ermitteln
        $linkCount = $entries % $entriesPerPage == 0 ? (int)$entries / $entriesPerPage : (int)ceil($entries / $entriesPerPage);
        if ($linkCount < 2)
        	return;

        // Ermitteln, wie viele Links den aktuellen umgeben werden
        $linkCountSurround = floor($showCount / 2);

        // Wenn sinnvoll ($showOuter===true, aber $linkCount<=$showCount*3), dann ueberschreiben wir hier $showContinuous
        if ($showOuter === true && $linkCount <= $showCount * 3)
            $showContinuous = true;

        // Angabe der aktuelllen Seite pruefen, gegebenenfalls neu setzen
        if ($linkCount < $activePage)
            $activePage = $linkCount - 1;
        elseif (!is_numeric($activePage) || $activePage < 0)
            $activePage = 0;

        // Jetzt berechnen wir erst einmal die Seitenzahlen fuer die erste, letzte, naechste und vorherige Seite
        // Sollte eine Seite nicht existieren, dann ist der Wert null (nicht 0!)
        $pageNext = $activePage + 1;

        if ($pageNext >= $linkCount - 1 && $activePage == $linkCount - 1)
            $pageNext = null;
        
        $pagePrev = $activePage - 1;

        if ($pagePrev <= 0 && $activePage == 0)
            $pagePrev = null;

        $pageFirst = 0;

        if ($activePage == 0)
            $pageFirst = null;

        $pageLast = $linkCount - 1;

        if ($activePage == $linkCount - 1)
            $pageLast = null;
            
        // Wenn kein Blaettern zu Stande kommt, dann mal schauen, ob der Nutzer den einzelnen Link sehen will
        if (($showSingleLink === false || $showActiveLink === false) && $entries <= $showCount) {
            $links = '';
            return $links;
        }

        // Alle Seitenzahlen durchgehen (egal, ob am Ende gezeigt oder nicht) und Seitenzahlen im Array speichern
        for ($i = 0; $i < $linkCount; $i++) {
            $links[] = $i;
        }
        // Links aus Seitenzahlen erstellen
        $this->_makeLinks();
				
        // Wenn alle Seiten angezeigt werden sollen...
        // ...oder Anzahl Links kleiner oder gleich der zu zeigenden ist, dann die Links speichern
        if ($showContinuous === true || $linkCount <= $showCount)
            $this->_addDelimiter3();
        else {
        	
            // Oder wenn nicht alle Links angezeigt werden sollen...
            // ...und nicht die aeusseren, dann Links speichern
            if ($showOuter === false) {
                // Wenn aktiver Link einer der aeusseren ist, dann dieses gesondert zeigen
                if ($activePage <= $linkCountSurround) {
                    $links = $this->_getOuterLinks('left');
                    $this->_addDelimiter3();
                    $this->_addDelimiter4(false, true);
                } elseif ($activePage >= $pageLast - $linkCountSurround) {
                    $links = $this->_getOuterLinks('right');

                    $this->_addDelimiter3();
                    $this->_addDelimiter4(true, false);
                }
                // Ansonsten die $showCount relevanten Links ermitteln und speichern
                else {
                    $links = $this->_getInnerLinks();
                    $this->_addDelimiter3();
                    $this->_addDelimiter4(true, true);
                }
            }
            // Oder wenn nicht alle Links angezeigt werden sollen...
            // ...und die aeusseren, dann Links speichern
            elseif ($showOuter === true) {
                // Alle moeglichen Links sammeln
                $temp[0] = $this->_getOuterLinks('left');
                $temp[1] = $this->_getInnerLinks();
                $temp[2] = $this->_getOuterLinks('right');

                // Alle drei Arrays in eins packen
                // Keine array_*-Funktion, da diese die Indizes loeschen
                $temp2 = $temp[0];

                for ($i = 1; $i < 3; $i++) {
                    foreach ($temp[$i] as $k => $v) {
                        $temp2[$k] = $v;
                    }
                }
                $temp = $temp2;
                unset ($temp2);
                ksort ($temp);

                // Zusammenhaengende Links (Abstand zum naechsten gleich 1) in eigene Arrays packen
                $last_index = 0;
                $j = 0;

                foreach ($temp as $k => $v) {
                    if ($k - $last_index > 1) {
                        $j++;
                    }

                    $temp2[$j][] = $v;

                    $last_index = $k;
                }

                // Arrays zusammenhaengender Links zu Strings zusammenfassen
                // Kein Funktionsaufruf, da diese auf $this->links zugreifen
                unset ($temp);

                for ($i = 0; $i < count($temp2); $i++) {
                    $temp[] = join($this->delimiter3, $temp2[$i]);
                }
                $links = join($this->delimiter4, $temp);
            }
        }

        // Links fuer Weiter/Zurueck und Anfang/Ende hinzufuegen, na ja, wenn es denn gewuenscht ist
        $this->_addNextPrev();
        $this->_addFirstLast();
		
		#echo '<pre>';
		#print_r($links);
		#echo '</pre>';
		
        return $links;
    }


    /** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum
     *
     *    @access private
     */
    private function _makeLinks() {
        // Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf... :)
        $activePage = &$this->activePage;
        $linkHref = &$this->linkHref;
        $linkActiveBracketLeft = &$this->linkActiveBracketLeft;
        $linkActiveBracketRight = &$this->linkActiveBracketRight;
        $linkActiveMore = &$this->linkActiveMore;
        $linkActiveText = &$this->linkActiveText;
        $linkBracketLeft = &$this->linkBracketLeft;
        $linkBracketRight = &$this->linkBracketRight;
        $linkMore = &$this->linkMore;
        $linkText = &$this->linkText;
        $showActiveLink = &$this->showActiveLink;
        $links = &$this->links;

        for ($i = 0; $i < count($links); $i++) {
            $num_link = $i + $this->numberFirstPage;
            $num_show = $i + 1;

            if ($i == $activePage)
                $links[$i] = "<a class='page_split' href='{$linkHref}{$num_link}{$this->extra}'{$linkActiveMore}>{$linkActiveBracketLeft}{$linkActiveText}{$num_show}{$linkActiveBracketRight}</a>";
            else
                $links[$i] = "<a class='page_split' href='{$linkHref}{$num_link}{$this->extra}'{$linkMore}>{$linkBracketLeft}{$linkText}{$num_show}{$linkBracketRight}</a>";
        }

        // Jetzt lassen wir den aktiven Link verschwinden - wenn denn gewuenscht
        if ($showActiveLink === false) {
            unset($links[$activePage]);
        }
        unset($temp);

        foreach ($links as $k => $v) {
            $temp[] = $v;
        }
        $links = $temp;
	}


    /** Gibt Array der inneren Links zurueck
     *
     *    @access private
     */
    private function _getInnerLinks() {
        // Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf... :)
        $activePage = &$this->activePage;
        $pageFirst = &$this->pageFirst;
        $pageLast = &$this->pageLast;
        $linkCountSurround = &$this->linkCountSurround;
        $linkCount = &$this->linkCount;
        $showCount = &$this->showCount;
        $links = &$this->links;

        $temp = false;
        $from = $activePage - $linkCountSurround;

        if ($from < 0) {
            $from = 0;
        }
        $to = $from + $showCount;

        if ($to > $linkCount - 1) {
            $to = $linkCount - 1;
        }

        for ($i = $from; $i < $to; $i++) {
            $temp[$i] = $links[$i];
        }

        return $temp;
        }


    /** Gibt Array mit aeusseren Links (links 'left' oder rechts 'right') zurueck
     *
     *    @access private
     */
    private function _getOuterLinks($side = null) {
        // Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf... :)
        $showActiveLink = &$this->showActiveLink;
        $linkCount = &$this->linkCount;
        $showCount = &$this->showCount;
        $links = &$this->links;

        $temp = false;

        if ($side === 'left') {
            for ($i = 0; $i < $showCount; $i++) {
                $temp[$i] = $links[$i];
            }
        } elseif ($side === 'right') {
            // Der erste Workaround, da sonst ein Link zu wenig gezeigt wird, wenn aktiver ausgeblendet
            if ($showActiveLink === false) {
                $from = $linkCount - $showCount - 1;
            } else {
                $from = $linkCount - $showCount;
            }
            $to = $from + $showCount;

            for ($i = $from; $i < $to; $i++) {
                $temp[$i] = $links[$i];
            }
        }

        return $temp;
        }


    /** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
     *
     *    @access private
     */
    private function _addDelimiter1() {
        if ($this->pageFirst !== null) {
            $this->links = $this->delimiter1 . $this->links;
        }

        if ($this->pageLast !== null) {
            $this->links = $this->links . $this->delimiter1;
        }
        }


    /** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
     *
     *    @access private
     */
    private function _addDelimiter2() {
        // Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf... :)
        $links = &$this->links;
        $pagePrev = &$this->pagePrev;
        $pageNext = &$this->pageNext;
        $delimiter2 = &$this->delimiter2;
        $delimiter4 = &$this->delimiter4;

        if ($pagePrev !== null &&
        // Verhindern, dass Delimiter2 gezeigt wird, wenn Delimiter4 schon da ist (pure Schoenheit)
        substr($links, 0, strlen($delimiter4)) != $delimiter4) {
            $links = $delimiter2 . $links;
        }

        if ($pageNext !== null && substr($links, -1 * strlen($delimiter4)) != $delimiter4) {
            $links = $links . $delimiter2;
        }
    }


    /** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
     *
     *    @access private
     */
    private function _addDelimiter3() { $this->links = join($this->delimiter3, $this->links); }


    /** Macht aus den im Array $links gepeicherten IDs Links mit allem Dran und Drum (siehe Beispiele)
     *
     *    @access private
     */
    private function _addDelimiter4($left = false, $right = false) {
        if ($left === true) {
            $this->links = $this->delimiter4 . $this->links;
        }

        if ($right === true) {
            $this->links = $this->links . $this->delimiter4;
        }
        }


    /** Fuegt dem Array Links fuer Weiter/Zurueck hinzu - wenn denn gewuenscht
     *
     *    @access private
     */
    private function _addNextPrev() {
        // Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf... :)
        $activePage = &$this->activePage;
        $linkHref = &$this->linkHref;
        $linkNextText = &$this->linkNextText;
        $linkPrevText = &$this->linkPrevText;
        $linkNextPrevMore = &$this->linkNextPrevMore;
        $showNextPrev = &$this->showNextPrev;
        $pageNext = &$this->pageNext;
        $pagePrev = &$this->pagePrev;
        $links = &$this->links;

        if ($showNextPrev === true) {
            $this->_addDelimiter2();

            $temp1 = $temp2 = '';

            if ($pagePrev !== null) {
                $temp1 = "<a class='page_split page_split_next_back' href='{$linkHref}" . ($pagePrev - $this->stepsNextPrev + 1 + $this->numberFirstPage).$this->extra."'{$linkNextPrevMore}>$linkPrevText</a>";
            }

            if ($pageNext !== null) {
                $temp2 = "<a class='page_split page_split_next_forward' href='{$linkHref}" . ($pageNext + $this->stepsNextPrev - 1 + $this->numberFirstPage).$this->extra. "'{$linkNextPrevMore}>$linkNextText</a>";
            }
            $links = $temp1 . $links . $temp2;
        }
        }


    /** Fuegt dem Array Links fuer Anfang/Ende hinzu - wenn denn gewuenscht
     *
     *    @access private
     */
    private function _addFirstLast() {
        // Hab keine Lust mit den langen Namen zu arbeiten, also erstelle ich Referenzen darauf... :)
        $linkHref = &$this->linkHref;
        $linkFirstText = &$this->linkFirstText;
        $linkLastText = &$this->linkLastText;
        $linkFirstLastMore = &$this->linkFirstLastMore;
        $showFirstLast = &$this->showFirstLast;
        $pageFirst = &$this->pageFirst;
        $pageLast = &$this->pageLast;
        $links = &$this->links;

        if ($showFirstLast === true) {
            $this->_addDelimiter1();

            $temp1 = $temp2 = '';

            if ($pageFirst !== null) {
                $temp1 = "<a class='page_split page_split_start' href='{$linkHref}" . ($pageFirst + $this->numberFirstPage).$this->extra."'{$linkFirstLastMore}>$linkFirstText</a>";
            }

            if ($pageLast !== null) {
                $temp2 = "<a class='page_split page_split_end' href='{$linkHref}" . ($pageLast + $this->numberFirstPage).$this->extra."'{$linkFirstLastMore}>$linkLastText</a>";
            }
            $links = $temp1 . $links . $temp2;
        }
     }


    /** Setzt Wert fuer Zahl der aktuelle Seite
     *    <b>Achtung</b> 10 hier, bedeutet bei der Ausgabe Seite 11
     *    Dieser Wert MUSS dynamisch festgelegt werden
     *    'ap' MUSS mit der letzten Variable bei $linkHref uebereinstimmen (ap = active page)
     *
     *    @access public
     *    @param (int) $activePage                        Zahl der aktuellen Seite, erhaelt man ungefaehr so: "$activePage=isset($_GET['ap']) ? $_GET['ap'] : 0;"
     *    @return (bool)                                    Gibt false zurueck, wenn $activePage keinen gueltigen Wert hat
     */
    public function setActivePage($activePage) {
        if (is_numeric($activePage)) {
            $this->activePage = round($activePage) - $this->numberFirstPage;
            return true;
        } else
            return false;
    }


    /** Setzt Wert fuer Zahl der ersten Seite
     *    Wer also beim Link auf Seite 1 nicht 0 sondern 12 uebergeben
     *    haben will, muss hier auch 12 eintragen.
     *
     *    @access public
     *    @param (int) $numberFirstPage                    Zahl der ersten Seite
     *    @return (bool)                                    Gibt false zurueck, wenn $numberFirstPage keinen gueltigen Wert hat
     */
    public function setNumberFirstPage($numberFirstPage) {
        if (is_numeric($numberFirstPage)) {
            $this->numberFirstPage = round($numberFirstPage);
            return true;
        } else {
            return false;
        }
        }


    /** Setzt Wert fuer Gesamtzahl aller Eintraege
     *
     *    @access public
     *    @param (int) $entries                            Anzahl aller Ergebnisse; erhaelt man ungefaehr so: "$entries=mysql_num_rows($resource);"
     *    @return (bool)                                    Gibt false zurueck, wenn $entries keinen gueltigen Wert hat
     */
    public function setEntries($entries) {
        if (is_numeric($entries)) {
            $this->entries = round($entries);
            return true;
        } else
            return false;
	}


    /** Setzt Wert fuer Anzahl Ergebnis pro Seite, die angezeigt werden sollen
     *
     *    @access public
     *    @param (int) $entriesPerPage                                Anzahl Ergebnis pro Seite, die angezeigt werden sollen
     *    @return (bool)                                    Gibt false zurueck, wenn $entriesPerPage keinen gueltigen Wert hat
     */
    public function setEntriesPerPage($entriesPerPage) {
        if (is_numeric($entriesPerPage) && $entriesPerPage >= 0) {
            $this->entriesPerPage = round($entriesPerPage);
            return true;
        } else {
			$this->entriesPerPage = 20;
            return true;
        }
    }


    /** Setzt Wert fuer Link, zu dem verwiesen werden soll
     *    <b>WICHTIG</b> Die Variable, die den Wert der aktuellen Seite enthaelt muss ganz am Ende stehen und dahinter ein = (siehe Beispiele)!!
     *    Die Seitenzahl wird immer hinten angehangen, weshalb das unbedingt beachtet werden muss!
     *
     *    @access public
     *    @param (string) $linkHref                        Link, zu dem verwiesen werden soll
     *    @return (bool)                                    Gibt false zurueck, wenn $linkHref keinen gueltigen Wert hat
     */
    public function setLinkHref($linkHref) {
        if (is_string($linkHref)) {
            if (substr($linkHref, -1) != '=') {
                $linkHref .= '=';
            }
            $this->linkHref = trim($linkHref);
            return true;
        } else
            return false;
    }

	public function perSite($zahl = '20') {
		$this->entriesPerPage = $zahl;
		return true;
    }


    /** Setzt Trennzeichen zwischen Links Anfang/Zurueck und Weiter/Ende
     *
     *    @access public
     *    @param (string) $delimiter1                        Zeichen, die zwischen Links Anfang/Zurueck und Weiter/Ende angezeigt werden (siehe 'Alle moeglichen Varianten')
     *    @return (bool)                                    Gibt false zurueck, wenn $delimiter1 keinen gueltigen Wert hat
     */
    public function setDelimiter1($delimiter1 = ' -- ') {
        if (is_string($delimiter1)) {
            $this->delimiter1 = $delimiter1;
            return true;
        } else {
            return false;
        }
    }


    /** Setzt Trennzeichen zwischen Links Zurueck und den Seitenzahlen sowie Weiter und den Seitenzahlen
     *
     *    @access public
     *    @param (string) $delimiter2                        Zeichen, die zwischen Links Zurueck und den Seitenzahlen sowie Weiter und den Seitenzahlen angezeigt werden (siehe 'Alle moeglichen Varianten')
     *    @return (bool)                                    Gibt false zurueck, wenn $delimiter2 keinen gueltigen Wert hat
     */
    public function setDelimiter2($delimiter2 = ' - ') {
        if (is_string($delimiter2)) {
            $this->delimiter2 = $delimiter2;
            return true;
        } else {
            return false;
        }
    }


    /** Setzt Trennzeichen zwischen Links der einzelnen Seiten
     *
     *    @access public
     *    @param (string) $delimiter3                        Zeichen, die zwischen Links der einzelnen Seiten gezeigt weden (siehe 'Alle moeglichen Varianten')
     *    @return (bool)                                    Gibt false zurueck, wenn $delimiter3 keinen gueltigen Wert hat
     */
    public function setDelimiter3($delimiter3 = ', ') {
        if (is_string($delimiter3)) {
            $this->delimiter3 = $delimiter3;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt Trennzeichen zwischen Links der einzelnen Seiten
     *
     *    @access public
     *    @param (string) $delimiter4                        Zeichen, die zwischen Links der einzelnen Seiten gezeigt werden (siehe 'Alle moeglichen Varianten')
     *    @return (bool)                                    Gibt false zurueck, wenn $delimiter4 keinen gueltigen Wert hat
     */
    public function setDelimiter4($delimiter4 = ' ... ') {
        if (is_string($delimiter4)) {
            $this->delimiter4 = $delimiter4;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt Wert fuer Zeichen vor und hinter aktivem Link
     *
     *    @access public
     *    @param (string) $linkActiveBracketLeft        Zeichen vor aktivem Link (siehe 'Variablen')
     *    @param (string) $linkActiveBracketRight        Zeichen hinter aktivem Link (siehe 'Variablen')
     *    @return (bool)                                    Gibt false zurueck, wenn $linkActiveBracketLeft oder $linkActiveBracketRight keinen gueltigen Wert hat
     */
    public function setLinkActiveBracket($linkActiveBracketLeft = '', $linkActiveBracketRight = '') {
        if (is_string($linkActiveBracketLeft) && is_string($linkActiveBracketRight)) {
            $this->linkActiveBracketLeft = trim($linkActiveBracketLeft);
            $this->linkActiveBracketRight = trim($linkActiveBracketRight);
            return true;
        } else {
            return false;
        }
        }


    /** Setzt erweiterte Einstellungen des aktiven Links
     *
     *    @access public
     *    @param (string) $linkActiveMore                Erweitere Einstellungen des aktiven Links (JavaScript, CSS, target, ...)
     *    @return (bool)                                    Gibt false zurueck, wenn $linkActiveMore keinen gueltigen Wert hat
     */
    public function setLinkActiveMore($linkActiveMore = '') {
        if (is_string($linkActiveMore)) {
            $linkActiveMore = ' ' . trim($linkActiveMore);
            $this->linkActiveMore = $linkActiveMore;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt Wert fuer Zeichen vor und hinter jeden (nicht aktiven) Link
     *
     *    @access public
     *    @param (string) $linkBracketLeft                Zeichen vor jedem (nicht aktiven) Link (siehe 'Variablen')
     *    @param (string) $linkBracketRight                Zeichen hinter jedem (nicht aktiven) Link (siehe 'Variablen')
     *    @return (bool)                                    Gibt false zurueck, wenn $linkBracketLeft keinen gueltigen Wert hat
     */
    public function setLinkBracket($linkBracketLeft = '', $linkBracketRight = '') {
        if (is_string($linkBracketLeft) && is_string($linkBracketRight)) {
            $this->linkBracketLeft = trim($linkBracketLeft);
            $this->linkBracketRight = trim($linkBracketRight);
            return true;
        } else {
            return false;
        }
        }


    /** Setzt erweiterte Einstellungen fuer jeden (nicht aktiven) Link
     *
     *    @access public
     *    @param (string) $linkMore                        Erweitere Einstellungen des jedes (nicht aktiven) Links (JavaScript, CSS, target, ...)
     *    @return (bool)                                    Gibt false zurueck, wenn $linkMore keinen gueltigen Wert hat
     */
    public function setLinkMore($linkMore = '') {
        if (is_string($linkMore)) {
            $linkMore = ' ' . trim($linkMore);
            $this->linkMore = $linkMore;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt Text fuer Links Zurueck/Weiter
     *
     *    @access public
     *    @param (string) $linkNextText                    Text des Links Weiter
     *    @param (string) $linkPrevText                    Text des Links Zurueck
     *    @return (bool)                                    Gibt false zurueck, wenn $linkNextText oder $linkPrevText keinen gueltigen Wert hat
     */
    public function setLinkNextPrevText($linkNextText = 'Weiter', $linkPrevText = 'Zur&uuml;ck') {
        if (is_string($linkNextText) && is_string($linkPrevText)) {
            $this->linkNextText = $linkNextText;
            $this->linkPrevText = $linkPrevText;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt erweiterte Einstellungen fuer Links Zurueck/Weiter
     *
     *    @access public
     *    @param (string) $linkNextPrevMore            Erweitere Einstellungen Links Zurueck/Weiter (JavaScript, CSS, target, ...)
     *    @return (bool)                                    Gibt false zurueck, wenn $linkNextPrevMore keinen gueltigen Wert hat
     */
    public function setLinkNextPrevMore($linkNextPrevMore = '') {
        if (is_string($linkNextPrevMore)) {
            $linkNextPrevMore = ' ' . trim($linkNextPrevMore);
            $this->linkNextPrevMore = $linkNextPrevMore;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt Text fuer Links Anfang/Ende
     *
     *    @access public
     *    @param (string) $linkFirstText                Text des Links Anfang
     *    @param (string) $linkLastText                    Text des Links Ende
     *    @return (bool)                                    Gibt false zurueck, wenn $linkFirstText oder $linkLastText keinen gueltigen Wert hat
     */
    public function setLinkFirstLastText($linkFirstText = 'Anfang', $linkLastText = 'Ende') {
        if (is_string($linkFirstText) && is_string($linkLastText)) {
            $this->linkFirstText = $linkFirstText;
            $this->linkLastText = $linkLastText;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt erweiterte Einstellungen fuer Links Anfang/Ende
     *
     *    @access public
     *    @param (string) $linkFirstLastMore            Erweitere Einstellungen Links Anfang/Ende (JavaScript, CSS, target, ...)
     *    @return (bool)                                    Gibt false zurueck, wenn $linkFirstLastMore keinen gueltigen Wert hat
     */
    public function setLinkFirstLastMore($linkFirstLastMore = '') {
        if (is_string($linkFirstLastMore)) {
            $linkFirstLastMore = ' ' . trim($linkFirstLastMore);
            $this->linkFirstLastMore = $linkFirstLastMore;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt den Wert, wie viele Links gezeigt werden sollen
     *
     *    @access public
     *    @param (int) $showCount                        Gibt Zahl der Links an, die nebeneinander gezeigt werden (ungerade Zahlen sind idealer)
     *    @return (bool)                                    Gibt false zurueck, wenn $showCount keinen gueltigen Wert hat
     */
    public function setShowCount($showCount = 3) {
        if (is_numeric($showCount) && $showCount >= 3) {
            $this->showCount = ceil($showCount);
            return true;
        } else {
            return false;
        }
        }


    /** Setzt den Wert, um wie viele Seiten bei Weiter/Zurueck gesprungen werden soll
     *
     *    @access public
     *    @param (bool) $stepsNextPrev                    Gibt Zahl der Seiten an, um die bei Weiter/Zurueck gesprungen werden soll
     *    @return (bool)                                    Gibt false zurueck, wenn $stepsNextPrev keinen gueltigen Wert hat
     */
    public function setStepsNextPrev($stepsNextPrev = null) {
        if (is_numeric($stepsNextPrev) && $stepsNextPrev >= 1) {
            $this->stepsNextPrev = round($stepsNextPrev);
            return true;
        } else {
            return false;
        }
        }


    /** Setzt den Wert, ob alle Links auf einmal gezeigt werden sollen
     *
     *    @access public
     *    @param (bool) $showContinuous                    Wenn true, dann werden alle Links auf einmal gezeigt
     *    @return (bool)                                    Gibt false zurueck, wenn $showOuter keinen gueltigen Wert hat
     */
    public function setShowContinuous($showContinuous = false) {
        if (is_bool($showContinuous)) {
            $this->showContinuous = $showContinuous;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt den Wert, ob aeussere Links der Seiten gezeigt werden sollen
     *
     *    @access public
     *    @param (bool) $showOuter                        Wenn true, dann werden aeusseren Links der Seiten angezeigt (siehe 'Alle moeglichen Varianten')
     *    @return (bool)                                    Gibt false zurueck, wenn $showOuter keinen gueltigen Wert hat
     */
    public function setShowOuter($showOuter = true) {
        if(is_bool($showOuter)) {
            $this->showOuter = $showOuter;
            return true;
        } else
            return false;
    }


    /** Setzt den Wert, ob Link der aktuellen Seite gezeigt werden soll
     *
     *    @access public
     *    @param (bool) $showActiveLink                    Wenn true, dann wird der Link der aktuellen Seite angezeigt
     *    @return (bool)                                    Gibt false zurueck, wenn $showActiveLink keinen gueltigen Wert hat
     */
    public function setShowActiveLink($showActiveLink = true) {
        if (is_bool($showActiveLink)) {
            $this->showActiveLink = $showActiveLink;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt den Wert, ob Links fuer Zurueck/Weiter gezeigt werden sollen
     *
     *    @access public
     *    @param (bool) $showNextPrev                    Wenn true, dann werden Links fuer Zurueck/Weiter angezeigt
     *    @return (bool)                                    Gibt false zurueck, wenn $showNextPrev keinen gueltigen Wert hat
     */
    public function setShowNextPrev($showNextPrev = true) {
        if (is_bool($showNextPrev)) {
            $this->showNextPrev = $showNextPrev;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt den Wert, ob Links fuer Anfang/Ende gezeigt werden sollen
     *
     *    @access public
     *    @param (bool) $showFirstLast                    Wenn true, dann werden Links fuer Anfang/Ende angezeigt
     *    @return (bool)                                    Gibt false zurueck, wenn $showFirstLast keinen gueltigen Wert hat
     */
    public function setShowFirstLast($showFirstLast = true) {
        if (is_bool($showFirstLast)) {
            $this->showFirstLast = $showFirstLast;
            return true;
        } else {
            return false;
        }
        }


    /** Setzt den Wert, ob ein einzelner Link gezeigt werden sollen
     *
     *    @access public
     *    @param (bool) $showSingleLink                    Wenn true, wird auch bei nur einer Seite ein Link zurueckgegeben, sonst nichts
     *    @return (bool)                                    Gibt false zurueck, wenn $showSingleLink keinen gueltigen Wert hat
     */
    public function setShowSingleLink($showSingleLink = false) {
        if (is_bool($showSingleLink)) {
            $this->showSingleLink = $showSingleLink;
            return true;
        } else {
            return false;
        }
    }


    /** Gibt Zahl zu zeigender Ergebnisse pro Seite zurueck
     *
     *    @access public
     *    @return (int)                                    Zahl zu zeigender Ergebnisse pro Seite
     */
    public function getEntriesPerPage() {
        return $this->entriesPerPage;
    }


    /** Gibt (eventuell korrigierte) Zahl der aktuellen Seite zurueck
     *
     *    @access public
     *    @return (int)                                    (eventuell korrigierte) Zahl der aktuellen Seite
     */
    public function getActivePage() {
        return $this->activePage;
    }


    /** Zeigt den Wert aller Variablen an
     *
     *    @access public
     */
    public function dump() {
        $width = 30;
        $vars = array (
            'activePage',
            'delimiter1',
            'delimiter2',
            'delimiter3',
            'delimiter4',
            'entries',
            'entriesPerPage',
            'linkActiveBracketLeft',
            'linkActiveBracketRight',
            'linkActiveMore',
            'linkActiveText',
            'linkBracketLeft',
            'linkBracketRight',
            'linkCount',
            'linkCountSurround',
            'linkFirstLastMore',
            'linkFirstText',
            'linkHref',
            'linkLastText',
            'linkMore',
            'linkNextPrevMore',
            'linkNextText',
            'linkPrevText',
            'linkText',
            'pageFirst',
            'pageLast',
            'pageNext',
            'pagePrev',
            'showActiveLink',
            'showContinuous',
            'showCount',
            'showFirstLast',
            'showNextPrev',
            'showOuter',
            'showSingleLink',
            'stepsNextPrev'
        );

        echo "<pre>\n";

        for ($i = 0; $i < count($vars); $i++) {
            $temp = $this->$vars[$i];

            if (is_bool($temp)) {
                $temp = $temp ? 'true' : 'false';
            }

            echo '$' . str_pad($vars[$i], $width, ' ', STR_PAD_RIGHT) . " = $temp\n";
        }

        if (is_array($this->links)) {
            echo '$links = ';
            print_r ($this->links);

            echo '$links = Array' . "\n(\n";

            for ($i = 0; $i < count($this->links); $i++) {
                echo "    [$i] => " . htmlentities($this->links[$i]) . "\n";
            }

            echo ")\n";
        } else {
            echo '$' . str_pad('links', $width, ' ', STR_PAD_RIGHT) . " = $this->links\n";

            echo '$' . str_pad('links', $width, ' ', STR_PAD_RIGHT) . ' = '
                . htmlentities(str_replace('<a href', "\n    <a href", $this->links)) . "\n";
        }

        echo "</pre>\n";
    }


    // Wer hier Werte setzt, der sollte sicher sein, dass sie richtig sind, geprueft werden sie nicht!
    // Also lieber die dafuer vorgesehenen Methoden nutzen.

    //////////////////////////////////////////////////
    // Erforderliche Variablen
    //////////////////////////////////////////////////
    /** Zahl der aktuellen Seite (Seite 1 hat Wert $this->numberFirstPage)
    *
    *    @access private
    *    @var (int)
    */
    private $activePage = 0;

    /** Welchen Wert soll die erste Seite haben?
     *
     *    @access private
     *    @var (int)
     */
    private $numberFirstPage = 1;

    /** Anzahl aller Eintraege
     *
     *    @access private
     *    @var (int)
     */
    private $entries = 0;

    /** Eintraege, die pro Seite gezeigt werden sollen
     *
     *    @access private
     *    @var (int)
     */

    private $entriesPerPage = '';

    /** URI zur Datei, plus Variablen, fuer Links
     *
     *    @access private
     *    @var (string)
     */
    private $linkHref = '';

    //////////////////////////////////////////////////
    // Optionale Variablen
    //////////////////////////////////////////////////
    /** Trennzeichen, siehe 'Variablen fuer Links'
    *
    *    @access private
    *    @var (string)
    */
    private $delimiter1 = ' - ';

    /**
     *
     *    @access private
     *    @var (string)
     */
    private $delimiter2 = ' - ';

    /** Trennzeichen, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $delimiter3 = ' - ';

    /** Trennzeichen, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $delimiter4 = ' ... ';

    /** Text vor aktivem Link, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkActiveText = '';

    /** Zeichen vor aktivem Link, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkActiveBracketLeft = '<span class="active_page_link">';

    /** Zeichen hinter aktivem Link, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkActiveBracketRight = '</span>';

    /** Zusaetzliche Angaben zum aktiven Link, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkActiveMore = '';

    /** Zeichen vor nicht-aktiven Links, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkText = '';

    /** Zeichen vor nicht-aktiven Links, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkBracketLeft = '<span class="inactive_page_link">';

    /** Zeichen hinter nicht-aktiven Links, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkBracketRight = '</span>';

    /** Zusaetzliche Angaben zu nicht-aktiven Links, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkMore = '';

    /** Text fuer 'Weiter' (naechste Seite), siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkNextText = '<span class="inactive_page_link">Weiter</span>';

    /** Text fuer 'Zurueck' (vorherige Seite), siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkPrevText = '<span class="inactive_page_link">Zur&uuml;ck</span>';

    /** Zusaetzliche Angaben zu Links 'Weiter' und 'Zurueck', siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkFirstLastMore = '';

    /** Text fuer 'Anfang' (erste Seite), siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkFirstText = '<span class="inactive_page_link">Anfang</span>';

    /** Text fuer 'Ende' (letzte Seite), siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkLastText = '<span class="inactive_page_link">Ende</span>';

    /** Zusaetzliche Angaben zu Links 'Anfang' und 'Ende', siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (string)
     */
    private $linkNextPrevMore = '';

    /** Anzahl Links, die nebeneinander gezeigt werden, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (int)
     */
    private $showCount = 3;

    /** Alle Links zeigen ja/nein, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (bool)
     */
    private $showContinuous = false;

    /** Aeussere Links zeigen ja/nein, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (bool)
     */
    private $showOuter = true;

    /** 'Weiter' und 'Zurueck' zeigen ja/nein, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (bool)
     */
    private $showNextPrev = true;

    /** 'Anfang' und 'Ende' zeigen ja/nein, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (bool)
     */
    private $showFirstLast = true;

    /** Link der aktuellen Seite zeigen ja/nein, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (bool)
     */
    private $showActiveLink = true;

    /** Wenn nur eine Seite, Link zeigen ja/nein, siehe 'Variablen fuer Links'
     *
     *    @access private
     *    @var (bool)
     */
    private $showSingleLink = false;

    /** Um wie viele Seiten Weiter/Zurueck springen soll
     *
     *    @access private
     *    @var (bool)
     */
    private $stepsNextPrev = 1;


    //////////////////////////////////////////////////
    // Voll und ganz interne Variablen
    //////////////////////////////////////////////////
    /** Anzahl aller Links
    *
    *    @access private
    *    @var (int)
    */
    public $linkCount = 0;

    /** Anzahl der Links, die den aktuellen umgeben
     *
     *    @access private
     *    @var (int)
     */
    private $linkCountSurround = 0;

    /** Seitenzahl fuer vorherige Seite
     *
     *    @access private
     *    @var (int)
     */
    private $pagePrev = 0;

    /** Seitenzahl fuer naechste Seite
     *
     *    @access private
     *    @var (int)
     */
    private $pageNext = 0;

    /** Seitenzahl fuer erste Seite
     *
     *    @access private
     *    @var (int)
     */
    private $pageFirst = 0;

    /** Seitenzahl fuer letzte Seite
     *
     *    @access private
     *    @var (int)
     */
    private $pageLast = 0;

    /** Array aller Links, String mit Links bei Uebergabe
     *
     *    @access private
     *    @var (mixed)
     */
    private $links = array ();
}
?>